/* ------------------------------------------------------------------
		       CLASS INTERFACE: vector
			      Tom Annau

		      NOTE TO CNS 185 STUDENTS:

  This header file is written in C++.  If you do not know C++, this
  file will be useless to you.  Please refer to the file "example.cc"
  instead for instructions on how to use the "vector" object.

  For those of you who do know C++, all methods are documented in this
  header file.  There are many methods not demonstrated in "example.cc"
  which are in this header file, but they are not essential for
  completing the assignments.
------------------------------------------------------------------- */

#ifndef vector_class
#define vector_class

#include "string.hh"

class vector {

/* ===================================================================
			P   U   B   L   I   C
=================================================================== */
public:

  /* -----------------------------------------------------------------
		     Constructors and destructor
  ----------------------------------------------------------------- */
  // Create vector, set all components to zero; dimension must be >= 0
  vector(int dimensions);

  // Copy constructor
  vector(const vector& v);

  // Create vector from string; format is like "1,4,2" or "{1,4,2}"
  vector(const string& s);

  // Create a vector, but do not allocate new space on free store
  // Instead, use data pointed to by *data pointer
  // When destructor is called, doesn't delete data
  vector(int dimensions, double *data);

  // Virtual destructor: deallocates free store space
  virtual ~vector(void);

  /* -----------------------------------------------------------------
		 Assignment operators and type casts
  ----------------------------------------------------------------- */
  // Copy one vector to another; must be of same size
  vector& operator = (const vector& v);

  // Convert vector to a string; will look like "{1,4,2}"
  string to_string(void) const;

  // Return a pointer pointing to vector's data
  const double* to_double_ptr(void) const;

  /* -----------------------------------------------------------------
			  Accessing elements
  ----------------------------------------------------------------- */
  // Return element at index; complain if range error
  // Returns by reference, so element can be modified with syntax
  // like: x[1] = 3;
  double& operator [] (int index) const;

  /* -----------------------------------------------------------------
			 Comparison operators
  ----------------------------------------------------------------- */
  // Compare elements of two vectors for equality
  // Two vectors must be of the same size.
  int operator == (const vector& v) const;

  // Compare elements of two vectors for inequality
  // Two vectors must be of the same size.
  int operator != (const vector& v) const;

  /* -----------------------------------------------------------------
		 Arithmetic with vectors and scalars
  ----------------------------------------------------------------- */

  // The following arithmetic operations are self-explanatory
  // In operators involving two vectors, they must be of the same
  // dimension, otherwise routine will complain

  vector& operator += (const vector& v);
  vector  operator +  (const vector& v) const;

  vector  operator -  (void) const;
  vector& operator -= (const vector& v);
  vector  operator -  (const vector& v) const;

  vector& operator += (double scalar);
  vector  operator +  (double scalar) const;

  friend vector operator + (double scalar, const vector& v);

  vector& operator -= (double scalar);
  vector  operator -  (double scalar) const;
  friend vector operator - (double scalar, const vector& v);
  
  vector& operator *= (double scalar);
  vector& operator /= (double scalar);

  vector operator * (double scalar) const;
  vector operator / (double scalar) const;
  friend vector operator * (double scalar, const vector& v);

  // Dot product two vectors
  friend double dot(const vector& v1, const vector& v2);

  /* -----------------------------------------------------------------
			Miscellaneous methods
  ----------------------------------------------------------------- */
  // Return dimension of vector
  int dimension(void) const;

  // Set all elements to zero
  void zero(void);

  // Set all elements to scalar
  void fill_with(double scalar);

  // Return Euclidean norm of vector
  double magnitude(void) const;

  // Return unit vector in direction of current vector
  vector unit_vector(void) const;

  // Change vector's dimension, zeros out all existing components
  virtual void resize(int new_dimension);

  // Increase a vector's dimension, keeps data, adds zeros to
  // new components.
  virtual void upsize(int new_dimension);

  /* -----------------------------------------------------------------
			    Stream methods
  ----------------------------------------------------------------- */
  // Output vector to ostream in binary format
  friend ostream& operator < (ostream& out, const vector& v);

  // Input vector from istream in binary format
  friend istream& operator > (istream& in, vector& v);

  // Output vector to ostream in ASCII format
  friend ostream& operator << (ostream& out, const vector& v);

  // Input vector from istream in ASCII format
  friend istream& operator >> (istream& in, vector& v);

  

/* ===================================================================
		      P  R  O  T  E  C  T  E  D
=================================================================== */
protected:

  int dims;
  double *value;
  short ref_counter;
   
  int same_dimension_as(const vector& v) const;
  void construct_from_string(string s);
};



/* ===================================================================
		   I n l i n e    f u n c t i o n s
=================================================================== */

/* -------------------------------------------------------------------
			     Constructors
------------------------------------------------------------------- */

inline vector::vector(const string& s)
{
  construct_from_string(s);
}

/* -------------------------------------------------------------------
		 Assignment operators and type casts
------------------------------------------------------------------- */

inline const double* vector::to_double_ptr(void) const
{
  return value;
}

/* -------------------------------------------------------------------
			  Accessing elements
------------------------------------------------------------------- */

inline double& vector::operator [] (int index) const
{
  if (index < 0 || index >= dims) {
    cerr << "ERROR: Index " << index << " is out of range for vector\n";
    return *(value);
  }
  else return *(value + index);
}

/* -------------------------------------------------------------------
			Arithmetic operations
------------------------------------------------------------------- */

inline vector vector::operator + (const vector& v) const
     return r(*this);
{ 
  r += v;
}

inline vector vector::operator - (const vector& v) const
     return r(*this);
{ 
  r -= v;
}

inline vector& vector::operator += (double scalar)
{
  for (register int i = 0; i < dims; *(value + i++) += scalar);
  return *this;
}

inline vector vector::operator +  (double scalar) const return r(*this);
{
  r += scalar;
}

inline vector operator + (double scalar, const vector& v) return r(v);
{
  r += scalar;
}

inline vector& vector::operator -= (double scalar)
{
  for (register int i = 0; i < dims; *(value + i++) -= scalar);
  return *this;
}

inline vector vector::operator -  (double scalar) const return r(*this);
{
  r -= scalar;
}

inline vector operator - (double scalar, const vector& v) return r(-v);
{
  r += scalar;
}

inline vector& vector::operator *= (double scalar)
{
  for (register int i = 0; i < dims; *(value + i++) *= scalar);
  return *this;
}

inline vector& vector::operator /= (double scalar)
{
  for (register int i = 0; i < dims; *(value + i++) /= scalar);
  return *this;
}

inline vector vector::operator * (double scalar) const return r(*this);
{
  r *= scalar;
}

inline vector vector::operator / (double scalar) const return r(*this);
{
  r /= scalar;
}

inline vector operator * (double scalar, const vector& v) return r(v);
{
  r *= scalar;
}

/* -------------------------------------------------------------------
			    Miscellaneous
------------------------------------------------------------------- */

inline int vector::dimension(void) const
{
  return dims;
}

inline void vector::fill_with(double scalar)
{
  for (register int i = 0; i < dims; *(value + i++) = scalar);
}

inline vector vector::unit_vector(void) const return u(*this);
{
  u /= (double) magnitude();
}

/* -------------------------------------------------------------------
			  Protected methods
------------------------------------------------------------------- */

inline int vector::same_dimension_as(const vector& v) const
{
  if (v.dims != dims) {
    cerr << "ERROR: Vectors not of same dimension\n";
    return 0;
  }
  else return 1;
}

#endif